/*
 * Copyright (c) 2024 endless-sky
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef EL_PROTOCOL_PROTOCOL_IMPL_H
#define EL_PROTOCOL_PROTOCOL_IMPL_H

#include "protocol.h"
#include "auth_processor.h"
#include "device_command_handler.h"
#include "firmware_upgrade_handler.h"
#include "model_handler.h"
#include "audio_command_handler.h"
#include "net_command_handler.h"
#include "user_command_handler.h"
#include "serial_command_handler.h"
#include "record_command_handler.h"
#include "config_command_handler.h"
#include "discovery_command_handler.h"

namespace El {
namespace Protocol {

/**
 * @brief 协议处理的具体实现类
 * 负责处理各种协议请求和响应的具体实现
 */
class ProtocolImpl : public IProtocol {
public:
    /**
     * @brief 构造函数
     * 初始化各种命令处理器
     */
    ProtocolImpl();

    /**
     * @brief 析构函数
     */
    ~ProtocolImpl() override = default;

    /**
     * @brief 解析传入的JSON-RPC请求
     * @param message 原始JSON消息
     * @param id 解析出的请求ID
     * @param method 解析出的方法名
     * @param params 解析出的参数
     * @return 解析是否成功
     */
    bool ParseRequest(const std::string &message, std::string &id, std::string &method, nlohmann::json &params);

    /**
     * @brief 解析传入的JSON-RPC响应
     * @param message 原始JSON消息
     * @param id 解析出的请求ID
     * @param result 解析出的结果
     * @return 解析是否成功
     */
    bool ParseResponse(const std::string &message, std::string &id, nlohmann::json &result);

    /**
     * @brief 处理协议消息
     * @param id 请求ID
     * @param method 方法名
     * @param params 参数
     * @param response 输出的响应
     * @return 处理是否成功
     */
    bool HandleMessage(std::string &id, std::string &method, nlohmann::json &params, nlohmann::json &response) override;

    /**
     * @brief 创建JSON-RPC请求
     * @param id 请求ID
     * @param method 方法名
     * @param params 参数
     * @return 格式化的JSON请求字符串
     */
    std::string CreateRequest(const std::string &id,
                              const std::string &method,
                              const nlohmann::json &params = nullptr) override;

    /**
     * @brief 创建错误响应
     * @param id 请求ID
     * @param code 错误码
     * @param message 错误消息
     * @param data 附加数据
     * @return 格式化的错误响应JSON字符串
     */
    std::string CreateErrorResponse(const std::string &id,
                                    int code,
                                    const std::string &message,
                                    const nlohmann::json &data = nullptr);

private:
    // 认证处理器
    std::unique_ptr<AuthProcessor> auth_processor_;

    // 设备协议处理器
    std::unique_ptr<DeviceCommandHandler> device_protocol_processor_;

    // 发现服务处理器
    std::unique_ptr<DiscoveryCommandHandler> discovery_command_handler_;

    // 固件升级处理器
    std::unique_ptr<FirmwareUpgradeHandler> firmware_upgrade_processor_;

    // 模型管理处理器
    std::unique_ptr<ModelHandler> model_handler_;

    // 音频管理处理器
    std::unique_ptr<AudioCommandHandler> audio_command_handler_;

    // 网络协议处理器
    std::unique_ptr<NetCommandHandler> net_command_handler_;

    // 用户管理处理器
    std::unique_ptr<UserCommandHandler> user_command_handler_;

    // 串口管理处理器
    std::unique_ptr<SerialCommandHandler> serial_command_handler_;

    // 录像管理处理器
    std::unique_ptr<RecordCommandHandler> record_command_handler_;

    // 通用配置处理器
    std::unique_ptr<ConfigCommandHandler> config_command_handler_;

    // 方法处理器映射表
    std::unordered_map<std::string, std::function<nlohmann::json(const std::string &, const nlohmann::json &)>>
        method_handlers_;
};

} // namespace Protocol
} // namespace El

#endif // EL_PROTOCOL_PROTOCOL_IMPL_H
